/**
 * 语音交互服务
 */
import { AudioRecorder } from '@/utils/audioRecorder'
import { AudioPlayer } from '@/utils/audioPlayer'
import { WebSocketClient } from '@/utils/websocketClient'


export class VoiceService {
  constructor() {
    this.audioRecorder = new AudioRecorder()
    this.audioPlayer = new AudioPlayer()
    this.websocketClient = new WebSocketClient()
    this.isInitialized = false
    this.sessionId = null
  }

  /**
   * 初始化语音服务
   */
  async initialize(sessionId) {
    try {
      this.sessionId = sessionId

      // 初始化音频录制器
      await this.audioRecorder.initialize()

      // 初始化音频播放器
      await this.audioPlayer.initialize()

      // 连接WebSocket
      await this.websocketClient.connect(sessionId)

      // 设置WebSocket消息处理器
      this.setupWebSocketHandlers()

      this.isInitialized = true
      console.log('语音服务初始化成功')

      return true
    } catch (error) {
      console.error('语音服务初始化失败:', error)
      throw error
    }
  }

  /**
   * 设置WebSocket消息处理器
   */
  setupWebSocketHandlers() {
    // 文本消息处理
    this.websocketClient.on('textMessage', (message) => {
      console.log('收到文本响应:', message)
      // 这里可以触发Vuex状态更新
      this.emit('textResponse', message)
    })

    // 音频数据处理
    this.websocketClient.on('audioData', (audioData) => {
      console.log('收到音频数据，大小:', audioData.byteLength)
      this.playAudio(audioData)
    })

    // 系统消息处理
    this.websocketClient.on('systemMessage', (message) => {
      console.log('系统消息:', message)
      this.emit('systemMessage', message)
    })

    // 打开软件或文件消息处理
    this.websocketClient.on('openAppMessage', (message) => {
      console.log('打开软件或文件消息:', message)
      this.emit('openAppMessage', message)
    })

    // 文件系统消息处理
    this.websocketClient.on('fileSystemMessage', (message) => {
      console.log('文件系统消息:', message)
      this.emit('fileSystemMessage', message)
    })

    // 应用操作消息处理
    this.websocketClient.on('appOperationMessage', (message) => {
      console.log('应用操作消息处理:', message)
      this.emit('appOperationMessage', message)
    })

    // 支持操作应用消息处理
    this.websocketClient.on('supportOperationAppMessage', (message) => {
      console.log('支持操作应用消息:', message)
      this.emit('supportOperationAppMessage', message)
    })

    // 提示消息处理
    this.websocketClient.on('tipsMessage', (message) => {
      console.log('提示消息:', message)
      this.emit('tipsMessage', message)
    })

    // 错误消息处理
    // 监听底层 WebSocket 的 errorMessage，将其转译为 VoiceService 层的 error 事件
    // 不会形成事件循环：WebSocketClient 只负责抛 errorMessage，VoiceService 只负责抛 error，两者命名空间隔离
    this.websocketClient.on('errorMessage', (message) => {
      console.error('服务器错误:', message)
      this.emit('error', message)
    })

    // 连接状态处理
    this.websocketClient.on('connected', () => {
      console.log('WebSocket连接成功')
      this.emit('connected')
    })

    this.websocketClient.on('disconnected', () => {
      console.log('WebSocket连接断开')
      this.emit('disconnected')
    })
  }

  /**
   * 开始语音录制
   */
  async startRecording() {
    if (!this.isInitialized) {
      throw new Error('语音服务未初始化')
    }

    try {
      this.audioRecorder.startRecording()
      console.log('开始语音录制')
      this.emit('recordingStarted')
      return true
    } catch (error) {
      console.error('开始录制失败:', error)
      this.emit('error', error.message)
      return false
    }
  }

  /**
   * 停止语音录制并发送
   */
  async stopRecording() {
    if (!this.isInitialized) {
      return
    }

    try {
      const audioData = await this.audioRecorder.stopRecording()
      if (audioData) {
        // 发送音频数据到服务器
        this.websocketClient.sendAudio(audioData)
        console.log('音频数据已发送')
        this.emit('recordingStopped')
        return true
      }
      return false
    } catch (error) {
      console.error('停止录制失败:', error)
      this.emit('error', error.message)
      return false
    }
  }

  /**
   * 播放音频
   */
  async playAudio(audioData) {
    try {
      const success = await this.audioPlayer.playAudio(audioData)
      if (success) {
        this.emit('audioPlaying')
      }
      return success
    } catch (error) {
      console.error('播放音频失败:', error)
      this.emit('error', error.message)
      return false
    }
  }

  /**
   * 发送文本消息
   */
  sendTextMessage(text) {
    if (!this.isInitialized || !this.websocketClient.isConnected()) {
      console.warn('服务未初始化或未连接')
      return false
    }

    try {
      this.websocketClient.sendText(text)
      console.log('文本消息已发送:', text)
      return true
    } catch (error) {
      console.error('发送文本消息失败:', error)
      this.emit('error', error.message)
      return false
    }
  }

  /**
   * 停止音频播放
   */
  stopAudio() {
    this.audioPlayer.stop()
    this.emit('audioStopped')
  }

  /**
   * 获取连接状态
   */
  getConnectionState() {
    return this.websocketClient.getConnectionState()
  }

  /**
   * 是否已连接
   */
  isConnected() {
    return this.websocketClient.isConnected()
  }

  /**
   * 获取录制状态
   */
  isRecording() {
    return this.audioRecorder.isRecording
  }

  /**
   * 获取播放状态
   */
  isPlaying() {
    return this.audioPlayer.getPlayingState()
  }

  /**
   * 事件处理器
   */
  on(event, handler) {
    if (!this.eventHandlers) {
      this.eventHandlers = new Map()
    }
    if (!this.eventHandlers.has(event)) {
      this.eventHandlers.set(event, [])
    }
    this.eventHandlers.get(event).push(handler)
  }

  off(event, handler) {
    if (this.eventHandlers && this.eventHandlers.has(event)) {
      const handlers = this.eventHandlers.get(event)
      const index = handlers.indexOf(handler)
      if (index > -1) {
        handlers.splice(index, 1)
      }
    }
  }

  emit(event, data) {
    if (this.eventHandlers && this.eventHandlers.has(event)) {
      this.eventHandlers.get(event).forEach(handler => {
        try {
          handler(data)
        } catch (error) {
          console.error('事件处理器错误:', error)
        }
      })
    }
  }

  /**
   * 释放资源
   */
  dispose() {
    this.audioRecorder.dispose()
    this.audioPlayer.dispose()
    this.websocketClient.close()
    this.isInitialized = false
    console.log('语音服务资源已释放')
  }
}
